Jassif Team Institution

ஏன் ஒரு கட்டமைப்பைப் பயன்படுத்த வேண்டும்?

Node.js கட்டமைப்புகள் வலை பயன்பாடுகள், APIகள் மற்றும் பலவற்றை உருவாக்க கட்டமைப்பு, அமைப்பு மற்றும் பொதுவான பயன்பாடுகளை வழங்குகின்றன.

பொதுவான வளர்ச்சி சவால்களுக்கு தயாரிக்கப்பட்ட தீர்வுகளை வழங்குவதன் மூலம் டெவலப்பர்கள் பயன்பாடுகளை வேகமாக உருவாக்க உதவுகின்றன.

ஒரு கட்டமைப்பைப் பயன்படுத்துவதன் நன்மைகள்:

Node.js கட்டமைப்புகளின் வகைகள்

Node.js கட்டமைப்புகள் அவற்றின் வடிவமைப்பு தத்துவம் மற்றும் அம்சங்களின் அடிப்படையில் பரந்த அளவில் வகைப்படுத்தப்படலாம்.

இந்த வகைகளைப் புரிந்துகொள்வது உங்கள் திட்டத்தின் தேவைகளுக்கு சரியான கட்டமைப்பைத் தேர்ந்தெடுப்பதில் உதவுகிறது.

முழு-ஸ்டாக் கட்டமைப்புகள்

இந்த கட்டமைப்புகள் முன்-முனை மற்றும் பின்-முனை வளர்ச்சி இரண்டிற்கும் தீர்வுகளை வழங்குகின்றன, பெரும்பாலும் ஒருங்கிணைந்த டெம்ப்ளேட்டிங் இயந்திரங்கள், ORM அமைப்புகள் மற்றும் பலவற்றுடன்.

எடுத்துக்காட்டுகள்: Meteor, Sails.js, AdonisJS

பயன்படுத்த வேண்டிய போது: முன்-முனை மற்றும் பின்-முனை கூறுகள் இரண்டையும் கொண்ட முழுமையான வலை பயன்பாடுகளை உருவாக்கும் போது

மினிமலிஸ்ட்/மைக்ரோ கட்டமைப்புகள்

இந்த கட்டமைப்புகள் இலகுவாக இருப்பதில் கவனம் செலுத்துகின்றன மற்றும் அத்தியாவசிய அம்சங்களை மட்டுமே வழங்குகின்றன, டெவலப்பர்கள் தேவையானவற்றைச் சேர்க்க அனுமதிக்கின்றன.

எடுத்துக்காட்டுகள்: Express.js, Koa, Fastify

பயன்படுத்த வேண்டிய போது: APIகள் அல்லது எளிய வலை சேவைகளை உருவாக்கும் போது, அதிகபட்ச கட்டுப்பாடு வேண்டும்

REST API கட்டமைப்புகள்

தானியங்கி சரிபார்ப்பு, ஆவணப்படுத்தல் மற்றும் பதிப்புகள் போன்ற அம்சங்களுடன் RESTful APIகளை உருவாக்க வடிவமைக்கப்பட்ட சிறப்பு கட்டமைப்புகள்.

எடுத்துக்காட்டுகள்: LoopBack, NestJS, Restify

பயன்படுத்த வேண்டிய போது: குறைந்தபட்ச பாய்லர்ப்ளேட் மூலம் வலுவான, உற்பத்தி-தயாரான APIகளை உருவாக்கும் போது

நிகழ்நேர கட்டமைப்புகள்

WebSockets மற்றும் சர்வர்-அனுப்பிய நிகழ்வுகளுக்கான உள்ளமைக்கப்பட்ட ஆதரவுடன் நிகழ்நேர பயன்பாடுகளுக்கு மேம்படுத்தப்பட்ட கட்டமைப்புகள்.

எடுத்துக்காட்டுகள்: Socket.io, Sails.js, FeathersJS

பயன்படுத்த வேண்டிய போது: அரட்டை பயன்பாடுகள், நேரடி புதுப்பிப்புகள் அல்லது எந்தவொரு நிகழ்நேர அம்சங்களையும் உருவாக்கும் போது

பிரபலமான Node.js கட்டமைப்புகள்

மிகவும் பிரபலமான Node.js கட்டமைப்புகள், அவற்றின் அம்சங்கள் மற்றும் எப்போது பயன்படுத்த வேண்டும் என்பதற்கான ஒரு விரிவான ஒப்பீடு இங்கே.

கட்டமைப்பு தேர்வு அளவுகோல்கள்

ஒரு கட்டமைப்பைத் தேர்ந்தெடுக்கும் போது, இந்த காரணிகளைக் கருத்தில் கொள்ளுங்கள்:

• திட்ட தேவைகள்: கட்டமைப்பு உங்கள் குறிப்பிட்ட தேவைகளை ஆதரிக்கிறதா?
• கற்றல் வளைவு: உங்கள் குழு எவ்வளவு விரைவாக உற்பத்தித் திறனைப் பெற முடியும்?
• செயல்திறன்: இது உங்கள் செயல்திறன் தேவைகளைப் பூர்த்தி செய்கிறதா?
• சமூகம் & ஆதரவு: செயலில் உள்ள வளர்ச்சி மற்றும் சமூக ஆதரவு உள்ளதா?
• சூழல்: பிளக்கின்கள் மற்றும் மிடில்வேர் கிடைக்கிறதா?

Express.js

Express என்பது அதன் எளிமை மற்றும் நெகிழ்வுத்தன்மைக்கு அறியப்பட்ட மிகவும் பிரபலமான மற்றும் பரவலாகப் பயன்படுத்தப்படும் Node.js கட்டமைப்பாகும்.

const express = require('express');
const app = express();
const port = 8080;

app.get('/', (req, res) => {
  res.send('Hello World from Express.js!');
});

app.listen(port, () => {
  console.log(`Express server running at http://localhost:${port}`);
});

முக்கிய அம்சங்கள்:

• குறைந்தபட்ச மற்றும் நெகிழ்வான வலை கட்டமைப்பு
• வலுவான ரூட்டிங் அமைப்பு
• HTTP பயன்பாடுகள் மற்றும் மிடில்வேர்
• டெம்ப்ளேட் இயந்திர ஆதரவு
• பல பிற கட்டமைப்புகளுக்கு அடித்தளமாக செயல்படுகிறது

Nest.js

Nest.js என்பது Angular ஆல் ஈர்க்கப்பட்ட ஒரு முற்போக்கான கட்டமைப்பாகும், TypeScript உடன் கட்டப்பட்டது மற்றும் திறமையான, அளவிடக்கூடிய சர்வர்-சைடு பயன்பாடுகளை உருவாக்க வடிவமைக்கப்பட்டது.

// app.controller.ts
import { Controller, Get } from '@nestjs/common';

@Controller()
export class AppController {
  @Get()
  getHello(): string {
    return 'Hello World from Nest.js!';
  }
}

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(8080);
  console.log(`Nest.js server running at http://localhost:8080`);
}
bootstrap();

முக்கிய அம்சங்கள்:

• TypeScript-முதல் வளர்ச்சி
• சார்பு உட்செலுத்துதல் அமைப்பு
• மாடுலர் கட்டிடக்கலை
• பெரும்பாலான Express மிடில்வேருடன் பொருந்தக்கூடியது
• GraphQL, WebSockets, மற்றும் மைக்ரோசர்விசஸ்களுக்கான உள்ளமைக்கப்பட்ட ஆதரவு
• வலுவான டைப்பிங் மற்றும் திடமான கட்டிடக்கலை வடிவங்கள்

Fastify

Fastify என்பது குறைந்தபட்ச மேலோட்டத்துடன் சிறந்த டெவலப்பர் அனுபவத்தை வழங்குவதில் கவனம் செலுத்தும் ஒரு வலை கட்டமைப்பாகும்.

const fastify = require('fastify')({ logger: true });
const port = 8080;

// Declare a route
fastify.get('/', async (request, reply) => {
  return { hello: 'Hello World from Fastify!' };
});

// Run the server
const start = async () => {
  try {
    await fastify.listen({ port });
    fastify.log.info(`Fastify server running at http://localhost:${port}`);
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

start();

முக்கிய அம்சங்கள்:

• அதிக செயல்திறன் (Express ஐ விட 2x வேகமானது)
• JSON Schema ஐப் பயன்படுத்தி ஸ்கீமா-அடிப்படையிலான சரிபார்ப்பு
• பிளக்கின் கட்டிடக்கலை
• உள்ளமைக்கப்பட்ட லாகர்
• இயல்பாக அசிங்க்ரோனஸ்
• TypeScript ஆதரவு

Koa.js

Express பின்னால் உள்ள குழுவால் உருவாக்கப்பட்ட Koa, வலை பயன்பாடுகள் மற்றும் APIகளுக்கான ஒரு சிறிய, மிகவும் வெளிப்படையான மற்றும் மிகவும் வலுவான அடித்தளமாக இருப்பதை நோக்கமாகக் கொண்டுள்ளது.

const Koa = require('koa');
const app = new Koa();
const port = 8080;

// Response middleware
app.use(async ctx => {
  ctx.body = 'Hello World from Koa.js!';
});

app.listen(port, () => {
  console.log(`Koa server running at http://localhost:${port}`);
});

முக்கிய அம்சங்கள்:

• async/await ஐப் பயன்படுத்தி நவீன மிடில்வேர் கட்டிடக்கலை
• திறம்பட செயல்படுத்தப்பட்ட பிழை கையாளுதல்
• இணைக்கப்பட்ட மிடில்வேர் இல்லை, இலகுவாக வைத்திருத்தல்
• try/catch மூலம் சிறந்த பிழை கையாளுதல்
• Express ஐ விட சுத்தமான, மிகவும் வெளிப்படையான குறியீட்டு தளம்

பிற பிரபலமான கட்டமைப்புகள்

Hapi.js

const Hapi = require('@hapi/hapi');

const init = async () => {
  const server = Hapi.server({
    port: 8080,
    host: 'localhost'
  });

  server.route({
    method: 'GET',
    path: '/',
    handler: (request, h) => {
      return 'Hello World from Hapi.js!';
    }
  });

  await server.start();
  console.log(`Hapi server running at ${server.info.uri}`);
};

init();

சிறந்தது: நிறுவன-நிலை பயன்பாடுகள் மற்றும் குறியீட்டை விட கட்டமைப்பை விரும்பும் குழுக்கள்.

Adonis.js

// routes.js
'use strict'

const Route = use('Route')

Route.get('/', () => {
  return 'Hello World from Adonis.js!'
})

// server.js
const { Ignitor } = require('@adonisjs/ignitor')

new Ignitor(require('@adonisjs/fold'))
  .appRoot(__dirname)
  .fireHttpServer()
  .catch(console.error)

சிறந்தது: முழு-ஸ்டாக் பயன்பாடுகள், குறிப்பாக Laravel அல்லது பிற MVC கட்டமைப்புகளுடன் பழக்கமுள்ள டெவலப்பர்களுக்கு.

Socket.io

const http = require('http');
const server = http.createServer();
const { Server } = require('socket.io');
const io = new Server(server);
const port = 8080;

io.on('connection', (socket) => {
  console.log('a user connected');

  socket.on('chat message', (msg) => {
    console.log('message: ' + msg);
    io.emit('chat message', msg);
  });

  socket.on('disconnect', () => {
    console.log('user disconnected');
  });
});

server.listen(port, () => {
  console.log(`Socket.io server running at http://localhost:${port}`);
});

சிறந்தது: அரட்டை பயன்பாடுகள், நேரடி டாஷ்போர்டுகள் மற்றும் கூட்டு கருவிகள் போன்ற நிகழ்நேர பயன்பாடுகள்.

சரியான கட்டமைப்பைத் தேர்ந்தெடுத்தல்

சரியான கட்டமைப்பைத் தேர்ந்தெடுப்பது உங்கள் திட்டத்தின் தேவைகள், உங்கள் குழுவின் நிபுணத்துவம் மற்றும் உங்கள் குறிப்பிட்ட இலக்குகளைப் பொறுத்தது. இந்த காரணிகளைக் கருத்தில் கொள்ளுங்கள்:

செயல்திறன் தேவைகள்

• அதிகபட்ச செயல்திறனுக்கு: Fastify
• சீரான செயல்திறன் மற்றும் அம்சங்களுக்கு: Express அல்லது Koa

திட்ட வகை

• REST APIகள்: Express, Fastify, அல்லது Restify
• முழு-ஸ்டாக் பயன்பாடுகள்: Adonis.js, Meteor, அல்லது Next.js
• நிறுவன பயன்பாடுகள்: Nest.js அல்லது Loopback
• நிகழ்நேர பயன்பாடுகள்: Socket.io உடன் Express அல்லது Koa

குழு அனுபவம்

• JavaScript டெவலப்பர்கள்: Express அல்லது Koa
• TypeScript டெவலப்பர்கள்: Nest.js
• Angular டெவலப்பர்கள்: Nest.js
• Laravel/PHP டெவலப்பர்கள்: Adonis.js

கற்றல் வளைவு

• கற்றல் எளிதானது: Express
• மிதமான கற்றல் வளைவு: Koa, Fastify, Hapi
• கடினமான கற்றல் வளைவு: Nest.js, Adonis.js

கட்டமைப்பு ஒப்பீடு

இந்த ஒப்பீடு அட்டவணை முக்கிய அளவுகோல்களின் அடிப்படையில் வெவ்வேறு Node.js கட்டமைப்புகளை விரைவாக மதிப்பிட உதவுகிறது:

கட்டமைப்பு தேர்வு வழிகாட்டி

Express.js ஐத் தேர்ந்தெடுக்கவும்:

• நீங்கள் Node.js க்கு புதியவர்
• உங்களுக்கு அதிகபட்ச நெகிழ்வுத்தன்மை தேவை
• நீங்கள் மிகப்பெரிய சூழலை விரும்புகிறீர்கள்
• நீங்கள் REST API அல்லது பாரம்பரிய வலை பயன்பாட்டை உருவாக்குகிறீர்கள்

NestJS ஐத் தேர்ந்தெடுக்கவும்:

• நீங்கள் ஒரு நிறுவன பயன்பாட்டை உருவாக்குகிறீர்கள்
• நீங்கள் TypeScript ஐ விரும்புகிறீர்கள்
• உங்களுக்கு சார்பு உட்செலுத்துதல் தேவை
• நீங்கள் Angular உடன் பழக்கமுள்ளவர்

Fastify ஐத் தேர்ந்தெடுக்கவும்:

• செயல்திறன் முக்கியமானது
• நீங்கள் JSON APIகளை உருவாக்குகிறீர்கள்
• உங்களுக்கு உள்ளமைக்கப்பட்ட ஸ்கீமா சரிபார்ப்பு வேண்டும்
• நீங்கள் async/await ஐ விரும்புகிறீர்கள்

Koa ஐத் தேர்ந்தெடுக்கவும்:

• நீங்கள் ஒரு மிகவும் நவீன Express மாற்று விரும்புகிறீர்கள்
• நீங்கள் async/await ஐப் பயன்படுத்த விரும்புகிறீர்கள்
• உங்களுக்கு சிறந்த பிழை கையாளுதல் தேவை
• கோரிக்கை/பதில் சுழற்சியில் அதிக கட்டுப்பாடு வேண்டும்

பயிற்சி